type runtime.g

179 uses

	runtime (current package)
		cgo_sigaction.go#L45: 		var g *g
		cgocall.go#L294: 		defer func(gp *g) {
		chan.go#L657: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
		debugcall.go#L160: 	mcall(func(gp *g) {
		debugcall.go#L195: 	callingG *g
		debugcall.go#L211: 	mcall(func(gp *g) {
		heapdump.go#L340: func dumpgoroutine(gp *g) {
		heapdump.go#L411: 	forEachG(func(gp *g) {
		lock_futex.go#L242: func beforeIdle(int64, int64) (*g, bool) {
		malloc.go#L1275: func deductAssistCredit(size uintptr) *g {
		malloc.go#L1276: 	var assistG *g
		mfinal.go#L44: var fing *g        // goroutine that runs finalizers
		mfinal.go#L153: func wakefing() *g {
		mfinal.go#L167: func finalizercommit(gp *g, lock unsafe.Pointer) bool {
		mgc.go#L360: 	stackRoots []*g
		mgc.go#L1295: 		gopark(func(g *g, nodep unsafe.Pointer) bool {
		mgc.go#L1608: 	forEachG(func(gp *g) {
		mgcmark.go#L133: 	forEachGRace(func(gp *g) {
		mgcmark.go#L406: func gcAssistAlloc(gp *g) {
		mgcmark.go#L531: func gcAssistAlloc1(gp *g, scanWork int64) {
		mgcmark.go#L734: func scanstack(gp *g, gcw *gcWork) int64 {
		mgcpacer.go#L731: func (c *gcControllerState) findRunnableGCWorker(pp *p, now int64) (*g, int64) {
		mgcscavenge.go#L282: 	g *g
		mgcsweep.go#L37: 	g      *g
		mprof.go#L965: 	forEachGRace(func(gp1 *g) {
		mprof.go#L978: 	forEachGRace(func(gp1 *g) {
		mprof.go#L1006: func tryRecordGoroutineProfileWB(gp1 *g) {
		mprof.go#L1016: func tryRecordGoroutineProfile(gp1 *g, yield func()) {
		mprof.go#L1065: func doRecordGoroutineProfile(gp1 *g) {
		mprof.go#L1098: 	isOK := func(gp1 *g) bool {
		mprof.go#L1108: 	forEachGRace(func(gp1 *g) {
		mprof.go#L1133: 		forEachGRace(func(gp1 *g) {
		mprof.go#L1175: func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
		netpoll.go#L429: 	var rg, wg *g
		netpoll.go#L454: 	var rg, wg *g
		netpoll.go#L485: 	var rg, wg *g
		netpoll.go#L517: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
		netpoll.go#L528: func netpollgoready(gp *g, traceskip int) {
		netpoll.go#L574: func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g {
		netpoll.go#L598: 			return (*g)(unsafe.Pointer(old))
		netpoll.go#L616: 	var rg *g
		netpoll.go#L625: 	var wg *g
		panic.go#L638: func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) {
		panic.go#L1113: func recovery(gp *g) {
		panic.go#L1290: func dopanic_m(gp *g, pc, sp uintptr) bool {
		panic.go#L1373: func shouldPushSigpanic(gp *g, pc, lr uintptr) bool {
		preempt.go#L61: 	g *g
		preempt.go#L104: func suspendG(gp *g) suspendGState {
		preempt.go#L341: func wantAsyncPreempt(gp *g) bool {
		preempt.go#L362: func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
		proc.go#L115: 	g0           g
		proc.go#L381: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceReason traceBlockReason, traceskip int) {
		proc.go#L407: func goready(gp *g, traceskip int) {
		proc.go#L502: func badmcall(fn func(*g)) {
		proc.go#L506: func badmcall2(fn func(*g)) {
		proc.go#L544: 	allgs    []*g
		proc.go#L559: 	allgptr **g
		proc.go#L562: func allgadd(gp *g) {
		proc.go#L579: func allGsSnapshot() []*g {
		proc.go#L591: func atomicAllG() (**g, uintptr) {
		proc.go#L593: 	ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
		proc.go#L598: func atomicAllGIndex(ptr **g, i uintptr) *g {
		proc.go#L599: 	return *(**g)(add(unsafe.Pointer(ptr), i*goarch.PtrSize))
		proc.go#L605: func forEachG(fn func(gp *g)) {
		proc.go#L617: func forEachGRace(fn func(gp *g)) {
		proc.go#L781: func dumpgstatus(gp *g) {
		proc.go#L890: func ready(gp *g, traceskip int, next bool) {
		proc.go#L976: func readgstatus(gp *g) uint32 {
		proc.go#L984: func casfrom_Gscanstatus(gp *g, oldval, newval uint32) {
		proc.go#L1012: func castogscanstatus(gp *g, oldval, newval uint32) bool {
		proc.go#L1042: func casgstatus(gp *g, oldval, newval uint32) {
		proc.go#L1141: func casGToWaiting(gp *g, old uint32, reason waitReason) {
		proc.go#L1154: func casgcopystack(gp *g) uint32 {
		proc.go#L1170: func casGToPreemptScan(gp *g, old, new uint32) {
		proc.go#L1182: func casGFromPreempted(gp *g, old, new uint32) bool {
		proc.go#L2795: func startlockedm(gp *g) {
		proc.go#L2847: func execute(gp *g, inheritTime bool) {
		proc.go#L2891: func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
		proc.go#L3260: func stealWork(now int64) (gp *g, inheritTime bool, rnow, pollUntil int64, newWork bool) {
		proc.go#L3373: func checkIdleGCNoP() (*p, *g) {
		proc.go#L3490: 	var tail *g
		proc.go#L3715: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
		proc.go#L3721: func park_m(gp *g) {
		proc.go#L3748: func goschedImpl(gp *g) {
		proc.go#L3764: func gosched_m(gp *g) {
		proc.go#L3772: func goschedguarded_m(gp *g) {
		proc.go#L3784: func gopreempt_m(gp *g) {
		proc.go#L3794: func preemptPark(gp *g) {
		proc.go#L3838: func goyield_m(gp *g) {
		proc.go#L3861: func goexit0(gp *g) {
		proc.go#L4323: func exitsyscall0(gp *g) {
		proc.go#L4458: func malg(stacksize int32) *g {
		proc.go#L4459: 	newg := new(g)
		proc.go#L4495: func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
		proc.go#L4591: func saveAncestors(callergp *g) *[]ancestorInfo {
		proc.go#L4624: func gfput(pp *p, gp *g) {
		proc.go#L4667: func gfget(pp *p) *g {
		proc.go#L4896: func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
		proc.go#L5437: 	forEachG(func(gp *g) {
		proc.go#L5866: 	forEachG(func(gp *g) {
		proc.go#L5913: func schedEnabled(gp *g) bool {
		proc.go#L5957: func globrunqput(gp *g) {
		proc.go#L5969: func globrunqputhead(gp *g) {
		proc.go#L5992: func globrunqget(pp *p, max int32) *g {
		proc.go#L6199: func runqput(pp *p, gp *g, next bool) {
		proc.go#L6234: func runqputslow(pp *p, gp *g, h, t uint32) bool {
		proc.go#L6235: 	var batch [len(pp.runq)/2 + 1]*g
		proc.go#L6311: func runqget(pp *p) (gp *g, inheritTime bool) {
		proc.go#L6432: func runqsteal(pp, p2 *p, stealRunNextG bool) *g {
		proc.go#L6464: func (q *gQueue) push(gp *g) {
		proc.go#L6473: func (q *gQueue) pushBack(gp *g) {
		proc.go#L6500: func (q *gQueue) pop() *g {
		proc.go#L6530: func (l *gList) push(gp *g) {
		proc.go#L6544: func (l *gList) pop() *g {
		race0.go#L31: func raceacquireg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L34: func racereleaseg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L36: func racereleaseacquireg(gp *g, addr unsafe.Pointer)                        { throw("race") }
		race0.go#L38: func racereleasemergeg(gp *g, addr unsafe.Pointer)                          { throw("race") }
		runtime2.go#L265: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
		runtime2.go#L268: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
		runtime2.go#L276: func (gp *g) guintptr() guintptr {
		runtime2.go#L285: func setGNoWB(gp **g, new *g) {
		runtime2.go#L360: 	g *g
		runtime2.go#L414: type g struct {
		runtime2.go#L534: 	g0      *g     // goroutine with scheduling stack
		runtime2.go#L541: 	gsignal       *g                // signal-handling g
		runtime2.go#L546: 	curg          *g       // current running goroutine
		runtime2.go#L584: 	waitunlockf          func(*g, unsafe.Pointer) bool
		runtime2.go#L968: 	g    *g
		select.go#L62: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
		select.go#L233: 		gp     *g
		signal_amd64.go#L49: func (c *sigctxt) preparePanic(sig uint32, gp *g) {
		signal_unix.go#L341: func doSigPreempt(gp *g, ctxt *sigctxt) {
		signal_unix.go#L398: func sigFetchG(c *sigctxt) *g {
		signal_unix.go#L411: 				gp := *(**g)(unsafe.Pointer(s.base()))
		signal_unix.go#L605: var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
		signal_unix.go#L606: var testSigusr1 func(gp *g) bool
		signal_unix.go#L619: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
		signal_unix.go#L779: func fatalsignal(sig uint32, c *sigctxt, gp *g, mp *m) *g {
		stack.go#L732: func adjustctxt(gp *g, adjinfo *adjustinfo) {
		stack.go#L758: func adjustdefers(gp *g, adjinfo *adjustinfo) {
		stack.go#L773: func adjustpanics(gp *g, adjinfo *adjustinfo) {
		stack.go#L779: func adjustsudogs(gp *g, adjinfo *adjustinfo) {
		stack.go#L793: func findsghi(gp *g, stk stack) uintptr {
		stack.go#L807: func syncadjustsudogs(gp *g, used uintptr, adjinfo *adjustinfo) uintptr {
		stack.go#L858: func copystack(gp *g, newsize uintptr) {
		stack.go#L1144: func isShrinkStackSafe(gp *g) bool {
		stack.go#L1164: func shrinkstack(gp *g) {
		stubs.go#L24: func getg() *g
		stubs.go#L40: func mcall(fn func(*g))
		stubs.go#L248: func setg(gg *g)
		time.go#L202: func resetForSleep(gp *g, ut unsafe.Pointer) bool {
		time.go#L249: 	goready(arg.(*g), 0)
		trace.go#L171: 	reader atomic.Pointer[g] // goroutine that called ReadTrace, or nil
		trace.go#L330: 	forEachGRace(func(gp *g) {
		trace.go#L533: 		gopark(func(gp *g, _ unsafe.Pointer) bool {
		trace.go#L676: func traceReader() *g {
		trace.go#L694: func traceReaderAvailable() *g {
		trace.go#L849: func traceCPUSample(gp *g, pp *p, stk []uintptr) {
		trace.go#L1574: func traceGoCreate(newg *g, pc uintptr) {
		trace.go#L1618: func traceGoUnpark(gp *g, skip int) {
		trace.go#L1797: func traceOneNewExtraM(gp *g) {
		traceback.go#L124: func (u *unwinder) init(gp *g, flags unwindFlags) {
		traceback.go#L134: func (u *unwinder) initAt(pc0, sp0, lr0 uintptr, gp *g, flags unwindFlags) {
		traceback.go#L794: func printcreatedby(gp *g) {
		traceback.go#L822: func traceback(pc, sp, lr uintptr, gp *g) {
		traceback.go#L834: func tracebacktrap(pc, sp, lr uintptr, gp *g) {
		traceback.go#L843: func traceback1(pc, sp, lr uintptr, gp *g, flags unwindFlags) {
		traceback.go#L1115: func gcallers(gp *g, skip int, pcbuf []uintptr) int {
		traceback.go#L1123: func showframe(sf srcFunc, gp *g, firstFrame bool, calleeID abi.FuncID) bool {
		traceback.go#L1185: func goroutineheader(gp *g) {
		traceback.go#L1222: func tracebackothers(me *g) {
		traceback.go#L1240: 	forEachGRace(func(gp *g) {
		traceback.go#L1314: func isSystemGoroutine(gp *g, fixed bool) bool {